home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Collection of Tools & Utilities
/
Collection of Tools and Utilities.iso
/
c
/
cppmatrx.zip
/
MATRIX.C
< prev
next >
Wrap
Text File
|
1991-02-02
|
9KB
|
381 lines
#include <stdlib.h>
#include <iostream.h>
#include <stdarg.h>
#include <math.h>
#include "matrix.h"
#include "matparse.h"
matrix::matrix (size_t matrix_length, ...)
{
if (matrix_length == 0)
matrix_error ("Cannot create a matrix of size 0.");
va_list argptr;
size_t elem_count;
matrix_size = matrix_length;
matrix_data = new matrix_t [matrix_size*matrix_size];
matrix_t *i;
size_t count;
va_start (argptr, matrix_length);
elem_count = matrix_size*matrix_size;
for (i = matrix_data, count = 1; count <= elem_count; i++, count++) {
*i = (matrix_t) (va_arg (argptr, matrix_t));
}
va_end (argptr);
}
matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
{
if (matrix_length == 0)
matrix_error ("Cannot create a matrix of size 0.");
size_t elem_count;
matrix_size = matrix_length;
matrix_data = new matrix_t [matrix_size*matrix_size];
matrix_t *i;
size_t count;
elem_count = matrix_size*matrix_size;
for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
*i = (matrix_t) fill_value;
}
void matrix::print_matrix (void)
{
matrix_t *i;
size_t row_count, column_count;
cout << '\n';
for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++) {
cout << *i << ' ';
if (column_count == (matrix_size - 1)) {
column_count = 0;
row_count++;
cout << '\n';
}
else
column_count++;
}
}
matrix::matrix (matrix &m)
{
matrix_t *i, *j;
size_t count, elem_count;
matrix_size = m.matrix_size;
elem_count = matrix_size*matrix_size;
matrix_data = new matrix_t [elem_count];
for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
*i = *j;
}
matrix matrix::operator= (matrix &m)
{
size_t elem_count;
matrix_t *i, *j;
size_t count;
delete matrix_data; // erase the current contents of the matrix on the left
// side of the assignment
matrix_size = m.matrix_size;
elem_count = matrix_size * matrix_size;
matrix_data = new matrix_t [elem_count]; // allocate space for the new matrix, identical to the argument
for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
*i = *j;
return *this;
}
matrix matrix::operator+ (matrix m)
{
if (matrix_size != m.matrix_size)
matrix_error ("Cannot add matrices of different sizes.");
matrix temp ("*",matrix_size);
matrix_t *i, *j, *k;
size_t counter;
size_t elem_count;
elem_count = matrix_size * matrix_size;
for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
counter <= elem_count; i++, j++, k++, counter++)
*k = *i + *j;
return temp;
}
matrix matrix::operator- (matrix m)
{
if (matrix_size != m.matrix_size)
matrix_error ("Cannot subtract matrices of different sizes.");
matrix temp ("*",matrix_size);
matrix_t *i, *j, *k;
size_t counter;
size_t elem_count;
elem_count = matrix_size * matrix_size;
for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
counter <= elem_count; i++, j++, k++, counter++)
*k = *i - *j;
return temp;
}
inline void swap (matrix_t &a, matrix_t &b)
{
matrix_t temp;
temp = a;
a = b;
b = temp;
}
void transpose (matrix &m)
{
size_t i,j;
for (i = 2; i <= m.matrix_size; i++)
for (j = 1; j <= i-1; j++)
swap (m (i,j), m (j,i));
}
matrix minor (matrix m, size_t m_row, size_t m_column)
{
if (m_row == 0 || m_column == 0)
matrix_error ("Invalid matrix indices passed to function minor.");
matrix temp ("*", m.matrix_size-1);
size_t column, row;
size_t temp_column, temp_row;
for (column = 1, temp_column = 1; column <= m.matrix_size; column++) {
if (column != m_column) {
for (row = 1, temp_row = 1; row <= m.matrix_size; row++)
if (row != m_row) {
temp (temp_row, temp_column) = m (row, column);
temp_row++;
}
temp_column++;
}
}
return temp;
}
matrix_t det (matrix m)
{
if (m.matrix_size == 1)
matrix_error ("Cannot evaluate the determinate of a matrix of size 1.");
if (m.matrix_size == 2)
return m (1,1)*m (2,2) - m (1,2)*m (2,1);
else {
size_t i;
matrix_t value = 0;
for (i = 1; i <= m.matrix_size; i++)
value += m (1,i) * cofactor (m, 1, i);
return value;
}
}
int matrix::operator== (matrix m)
{
if (matrix_size == m.matrix_size)
return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
else
return 0;
}
int matrix::operator!= (matrix m)
{
if (matrix_size == m.matrix_size)
return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
else
return 1;
}
matrix operator* (matrix m, double r)
{
matrix temp ("*",m.matrix_size);
matrix_t *i, *t;
size_t count, elem_count = m.matrix_size*m.matrix_size;
for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
*t = *i * r;
return temp;
}
matrix operator* (double r, matrix m)
{
matrix temp ("*",m.matrix_size);
matrix_t *i, *t;
size_t count, elem_count = m.matrix_size*m.matrix_size;
for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
*t = *i * r;
return temp;
}
matrix operator* (matrix m, int r)
{
matrix temp ("*",m.matrix_size);
matrix_t *i, *t;
size_t count, elem_count = m.matrix_size*m.matrix_size;
for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
*t = *i * r;
return temp;
}
matrix operator* (int r, matrix m)
{
matrix temp ("*",m.matrix_size);
matrix_t *i, *t;
size_t count, elem_count = m.matrix_size*m.matrix_size;
for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
*t = *i * r;
return temp;
}
matrix_t cofactor (matrix m, size_t m_row, size_t m_column)
{
if (m_row == 0 || m_column == 0)
matrix_error ("Invalid matrix indices passed to function cofactor.");
int factor;
if ((m_row+m_column) % 2)
factor = (-1);
else
factor = 1;
return (matrix_t) factor * det (minor (m, m_row, m_column));
}
matrix matrix::operator- (void)
{
matrix temp ("*",matrix_size);
matrix_t *i, *t;
size_t count, elem_count = matrix_size*matrix_size;
for (i = matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
*t = -*i;
return temp;
}
matrix matrix::operator* (matrix m)
{
if (matrix_size != m.matrix_size)
matrix_error ("Cannot multiply matrices of different dimensions.");
size_t i,j,k;
matrix temp ("*",matrix_size);
for (i = 1; i <= matrix_size; i++) {
for (j = 1; j <= matrix_size; j++) {
matrix_t value = 0;
for (k = 1; k <= matrix_size; k++)
value += get_elem (j,k)*m (k,i);
temp (j,i) = value;
}
}
return temp;
}
ostream& operator<< (ostream &s, matrix m)
{
size_t i,j;
s << '\n';
for (i = 1; i <= m.matrix_size; i++) {
for (j = 1; j <= m.matrix_size; j++)
s << m (i,j) << ' ';
s << '\n';
}
return s;
}
istream& operator>> (istream &s, matrix &m)
{
size_t i,j;
delete m.matrix_data;
s >> m.matrix_size;
m.matrix_data = new matrix_t [m.matrix_siz